home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp95 / freyja.exe / lha / KEY.C < prev    next >
C/C++ Source or Header  |  1992-04-13  |  6KB  |  375 lines
  1. /* KEY.C -- Key Input Routines
  2.  
  3.     Written March 1991 by Craig A. Finseth
  4.     Copyright 1991 by Craig A. Finseth
  5. */
  6.  
  7. #include "freyja.h"
  8.  
  9. #define ZCY        '\031'
  10.  
  11. static struct buffer *buf_buf = NULL;
  12. static struct mark *buf_pt = NULL;
  13.  
  14. static int mac_buf[MACROMAX] = { KEYNONE };
  15. static int *mac_ptr = mac_buf;
  16. static FLAG mac_record = FALSE;
  17. static int mac_arg = KEYNONE;
  18.  
  19. static char *str_ptr = NULL;
  20. static int str_len = 0;
  21.  
  22. /* ------------------------------------------------------------ */
  23.  
  24. /* Ask a yes/no question in the echo line.  Return KEYQUIT, KEYABORT,
  25. 'Y', or 'N'. */
  26.  
  27. int
  28. KAsk(msg)
  29.     char *msg;
  30.     {
  31.     DEcho(msg);
  32.     for (;;) {
  33.         switch (xtoupper(KGetChar())) {
  34.  
  35.         case KEYQUIT:
  36.             DModeLine();
  37.             return(KEYQUIT);
  38.             /*break;*/
  39.  
  40.         case KEYABORT:
  41.         case ESC:
  42.         case BEL:
  43.             DModeLine();
  44.             return(KEYABORT);
  45.             /*break;*/
  46.  
  47.         case SP:
  48.         case 'Y':
  49.             DModeLine();
  50.             return('Y');
  51.             /*break;*/
  52.  
  53.         case DEL:
  54.         case BS:
  55.         case 'N':
  56.             DModeLine();
  57.             return('N');
  58.             /*break;*/
  59.  
  60.         default:
  61.             TBell();
  62.             break;
  63.             }
  64.         }
  65.     }
  66.  
  67.  
  68. /* ------------------------------------------------------------ */
  69.  
  70. /* begin defining keyboard macro */
  71.  
  72. void
  73. KBegMac()
  74.     {
  75.     uarg = 0;
  76.     if (mac_arg > 0) {
  77.         DError("Using macro");
  78.         return;
  79.         }
  80.     mac_ptr = mac_buf;
  81.     mac_record = TRUE;
  82.     }
  83.  
  84.  
  85. /* ------------------------------------------------------------ */
  86.  
  87. /* Echo msg if no char is typed within interval return true if msg
  88. printed, else false */
  89.  
  90. FLAG
  91. KDelayPrompt(msg)
  92.     char *msg;
  93.     {
  94.     int cnt;
  95.  
  96.     for (cnt = 0; cnt < DELAYCOUNT; cnt++) {
  97.         if (KIsKey() == 'Y') return(FALSE);
  98.         }
  99.     DEchoNM(msg);
  100.     return(TRUE);
  101.     }
  102.  
  103.  
  104. /* ------------------------------------------------------------ */
  105.  
  106. /* finish defining keyboard macro */
  107.  
  108. void
  109. KEndMac()
  110.     {
  111.     uarg = 0;
  112.     mac_record = FALSE;
  113.     mac_ptr -= 2;
  114.     if (mac_ptr < mac_buf) mac_ptr = mac_buf;
  115.     *mac_ptr = KEYNONE;
  116.     }
  117.  
  118.  
  119. /* ------------------------------------------------------------ */
  120.  
  121. /* Switch input to be from the specified buffer.  The entire buffer is
  122. read, starting from the beginning.  The point is preserved. */
  123.  
  124. void
  125. KFromBuf(bptr)
  126.     struct buffer *bptr;
  127.     {
  128.     struct buffer *savebuf = cbuf;
  129.  
  130.     BBufGoto(bptr);
  131.     if ((buf_pt = BMarkCreate()) != NULL) {
  132.         buf_buf = bptr;
  133.         BMoveToStart();
  134.         }
  135.     BBufGoto(savebuf);
  136.     }
  137.  
  138.  
  139. /* ------------------------------------------------------------ */
  140.  
  141. /* do keyboard macro */
  142.  
  143. void
  144. KFromMac()
  145.     {
  146.     if (mac_record) {
  147.         DError("Creating macro");
  148.         uarg = 0;
  149.         return;
  150.         }
  151.     mac_arg = uarg;
  152.     mac_ptr = mac_buf;
  153.     uarg = 0;
  154.     }
  155.  
  156.  
  157. /* ------------------------------------------------------------ */
  158.  
  159. /* Switch input to be from the supplied string. */
  160.  
  161. void
  162. KFromStr(str, len)
  163.     char *str;
  164.     int len;
  165.     {
  166.     if (str == NULL || len <= 0) {
  167.         str_len = 0;
  168.         }
  169.     else    {
  170.         str_ptr = str;
  171.         str_len = len;
  172.         }
  173.     }
  174.  
  175.  
  176. /* ------------------------------------------------------------ */
  177.  
  178. /* Get a character and handle keyboard macros */
  179.  
  180. int
  181. KGetChar()
  182.     {
  183.     int chr;
  184.     
  185.     if (buf_buf != NULL) {
  186.         struct buffer *savebuf = cbuf;
  187.  
  188.         BBufGoto(buf_buf);
  189.         if (!BIsEnd()) {    /* get next char */
  190.             chr = BGetCharAdv();
  191.             BBufGoto(savebuf);
  192.             return(chr);
  193.             }
  194.         BPointToMark(buf_pt);
  195.         BMarkDelete(buf_pt);
  196.         buf_buf = NULL;
  197.         BBufGoto(savebuf);
  198.         }
  199.     if (str_len > 0) {
  200.         str_len--;
  201.         return(*str_ptr++);
  202.         }
  203.     while (mac_arg > 0) {
  204.         chr = *mac_ptr++;
  205.         if (chr != KEYNONE) return(chr);
  206.         mac_arg--;
  207.         mac_ptr = mac_buf;
  208.         DIncrDisplay();
  209.         TForce();
  210.         }
  211.     TForce();
  212. #if defined(MSDOS)
  213.     if (c.g.key_type == 'J') {
  214.         chr = JGetKey();
  215.         }
  216.     else
  217. #endif
  218.         chr = TGetKey();
  219.  
  220.     if (c.g.ESC_swap != ESC) {
  221.         if (chr == ESC) chr = c.g.ESC_swap;
  222.         else if (chr == c.g.ESC_swap) chr = ESC;
  223.         }
  224.     if (c.g.CTX_swap != ZCX) {
  225.         if (chr == ZCX) chr = c.g.CTX_swap;
  226.         else if (chr == c.g.CTX_swap) chr = ZCX;
  227.         }
  228.     if (mac_record) {
  229.         *mac_ptr++ = chr;
  230.         if (mac_ptr > &mac_buf[MACROMAX - 1]) {
  231.             DError("Keyboard macro full");
  232.             mac_ptr--;
  233.             }
  234.         *mac_ptr = KEYNONE;
  235.         }
  236.     return(chr);
  237.     }
  238.  
  239.  
  240. /* ------------------------------------------------------------ */
  241.  
  242. /* Input a string argument. Return KEYQUIT, KEYABORT, or 'Y' (if ok). */
  243.  
  244. int
  245. KGetStr(msg, str, len)
  246.     char *msg;
  247.     char *str;
  248.     int len;
  249.     {
  250.     char sbuf[BIGBUFFSIZE];
  251.     char buf[BIGBUFFSIZE];
  252.     int c;
  253.     int amt;
  254.     int retval;
  255.  
  256.     *sbuf = NUL;
  257.     for (retval = KEYNONE; retval == KEYNONE; ) {
  258.         xsprintf(buf, "%s: %s", msg, sbuf);
  259.         DEcho(buf);
  260.  
  261.         amt = strlen(sbuf);
  262.         c = KGetChar();
  263.         switch (c) {
  264.  
  265.         case KEYQUIT:
  266.             retval = KEYQUIT;
  267.             break;
  268.  
  269.         case KEYABORT:
  270.         case ESC:
  271.         case BEL:
  272.             retval = KEYABORT;
  273.             break;
  274.  
  275.         case CR:
  276.             retval = 'Y';
  277.             break;
  278.  
  279.         case BS:
  280.         case DEL:
  281.             if (*sbuf != NUL) sbuf[amt - 1] = NUL;
  282.             break;
  283.  
  284. #if defined(MSDOS)
  285.         case 0x100 + 97:    /* Ctrl-F4 */
  286. #endif
  287.         case ZCY:
  288.             KFromBuf(kill_buf);
  289.             break;
  290.  
  291.         default:
  292.             if (amt >= len - 1) {
  293.                 sbuf[amt - 1] = NUL;
  294.                 TBell();
  295.                 }
  296.  
  297.             if (c == ZCQ) c = KGetChar();
  298.             sbuf[amt] = c;
  299.             sbuf[amt + 1] = NUL;
  300.             break;
  301.             }
  302.         }
  303.     if (retval != KEYQUIT && retval != KEYABORT && *sbuf != NUL)
  304.         xstrcpy(str, sbuf);
  305.     DModeLine();
  306.     return(retval);
  307.     }
  308.  
  309.  
  310. /* ------------------------------------------------------------ */
  311.  
  312. /* Is key available from macro? */
  313.  
  314. char
  315. KIsKey()
  316.     {
  317.     if (buf_buf != NULL) {
  318.         struct buffer *savebuf = cbuf;
  319.  
  320.         BBufGoto(buf_buf);
  321.         if (!BIsEnd()) {
  322.             BBufGoto(savebuf);
  323.             return('Y');
  324.             }
  325.         BPointToMark(buf_pt);
  326.         BMarkDelete(buf_pt);
  327.         buf_buf = NULL;
  328.         BBufGoto(savebuf);
  329.         }
  330.     if (str_len > 0) return('Y');
  331.     if (!mac_record && mac_arg > 0) return('Y');
  332. #if defined(MSDOS)
  333.     if (c.g.key_type == 'J')
  334.         return(JIsKey());
  335.     else
  336. #endif
  337.         return(TIsKey());
  338.     }
  339.  
  340.  
  341. /* ------------------------------------------------------------ */
  342.  
  343. /* Return a pointer to the start of the keyboard macro. */
  344.  
  345. int *
  346. KMacPtr()
  347.     {
  348.     return(mac_buf);
  349.     }
  350.  
  351.  
  352. /* ------------------------------------------------------------ */
  353.  
  354. /* Internal routine to display current argument */
  355.  
  356. FLAG
  357. KUArg(targ)
  358.     int targ;
  359.     {
  360.     int cnt;
  361.     char buf[LINEBUFFSIZE];
  362.  
  363.     if (targ == 4) {
  364.         for (cnt = 0; cnt < DELAYCOUNT; cnt++) {
  365.             if (KIsKey() == 'Y') return(FALSE);
  366.             }
  367.         }
  368.     xsprintf(buf, "Arg: %d", targ);
  369.     DEchoNM(buf);
  370.     return(TRUE);
  371.     }
  372.  
  373.  
  374. /* KEY.C -- Key Input Routines */
  375.